{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib\n",
    "import numpy as np\n",
    "import os\n",
    "import pickle\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline  \n",
    "matplotlib.rcParams['figure.figsize'] =(12, 5)\n",
    "\n",
    "def smooth(row, explen=None):\n",
    "    if explen is None:\n",
    "        N = max(int(len(row)*0.02), 1)\n",
    "    else:\n",
    "        N = max(int(explen*0.02), 1)\n",
    "    row = np.convolve(row, np.array(np.ones((N)))/float(N), 'valid')\n",
    "    return row\n",
    "\n",
    "def plot(fields, first=None, legends=None, alpha=None, rescale_y=None, startpoints=None):\n",
    "    lines = []\n",
    "    for field in fields:\n",
    "        for ind, (data, header) in enumerate(zip(datas, headers)):\n",
    "            try:\n",
    "                header.index(field)\n",
    "                row = data[:, header.index(field)]\n",
    "                row = smooth(row, first)[:first]\n",
    "                _alpha = alpha if alpha else (0.2 if row.shape[0] == first else 1.0)\n",
    "                if rescale_y:\n",
    "                    row = (row-rescale_y[0])/(rescale_y[1]-rescale_y[0])*100\n",
    "                if startpoints is None:\n",
    "                    line, =plt.plot(range(row.shape[0]), row, alpha=_alpha)\n",
    "                else:\n",
    "                    line, =plt.plot(range(startpoints[ind], startpoints[ind]+row.shape[0]),\n",
    "                                    row, alpha=_alpha)\n",
    "                lines.append(line)\n",
    "            except:\n",
    "                pass\n",
    "    if first is not None:\n",
    "        plt.xlim(0, first)\n",
    "    plt.legend(handles=lines, labels=legends if legends else filenames)  # , loc=4)\n",
    "\n",
    "def readfile(filename):\n",
    "    with open(filename) as f:\n",
    "        #data = map(lambda x: x.strip().split(','), f.readlines())\n",
    "        data = list(map(lambda x: x.strip().split(','), f.readlines()))\n",
    "    if len(data) is 0 :\n",
    "        return None, None\n",
    "    header = data[0]\n",
    "    data = np.array(data[1:])\n",
    "    data[data == ''] = '0'\n",
    "    data = np.array(data, dtype='float')\n",
    "    return header, data\n",
    "\n",
    "def parse_target(targets):\n",
    "    filenames, startpoints = [], []\n",
    "    for target in targets:\n",
    "        if isinstance(target, tuple):\n",
    "            filenames.append(target[0])\n",
    "            startpoints.append(target[1])\n",
    "        else:\n",
    "            filenames.append(target)\n",
    "            startpoints.append(0)\n",
    "    #filenames = map(lambda x: './outputs/'+x, filenames)\n",
    "    filenames = list(map(lambda x: './outputs/'+x, filenames))\n",
    "    return filenames, startpoints\n",
    "\n",
    "def moving_average(a) :\n",
    "    ret = np.cumsum(a, dtype=float)\n",
    "    rng = np.asarray(range(1,len(a)+1), dtype=float)\n",
    "    ret = np.divide(ret, rng)\n",
    "    return ret\n",
    "\n",
    "\n",
    "def moving_average_v2(a, n=10):\n",
    "    ret = np.cumsum(a, dtype=float)\n",
    "    ret[n:] = ret[n:] - ret[:-n]\n",
    "    return ret[n - 1:] / n\n",
    "\n",
    "\n",
    "def plot_reward_curve(file_path, mavg=True, mavg_v=1, n=-1, target_field='EpRewMean',\n",
    "                      print_header=False, txt_offset=1.0, conv=100):\n",
    "    plt.figure()\n",
    "    cont =  'progress.csv' not in file_path\n",
    "    if cont :\n",
    "        header, data = readfile(os.path.join(file_path, 'progress.csv'))\n",
    "    else :\n",
    "        header, data = readfile(file_path)\n",
    "    if print_header:\n",
    "        print (header)\n",
    "    target_field_index = header.index(target_field)\n",
    "    Y = data[:, target_field_index]\n",
    "    Yindices = np.where(Y != 0)\n",
    "    Y = Y[Yindices]\n",
    "    \n",
    "    t=2\n",
    "#    print((len(Y)%5)*5)\n",
    "#    Y = Y[:(len(Y)%5)*5]\n",
    "    print(len(Y))\n",
    "    if cont :\n",
    "        while os.path.exists(file_path+'_'+str(t)) :\n",
    "            t += 1\n",
    "        if t > 2 :\n",
    "            for i in range(t) :\n",
    "                if i <2 :\n",
    "                    continue\n",
    "            \n",
    "                head,d = readfile(os.path.join(file_path+'_'+str(i), 'progress.csv'))\n",
    "                if head is None :\n",
    "                    continue\n",
    "                target_field_index = head.index(target_field)\n",
    "                y = d[:,target_field_index] \n",
    "         #       print(len(y))\n",
    "           #     y = y[:(len(y)%5)*5]\n",
    "                if i is not t-1 :\n",
    "                    yindices = np.where(y != 0)\n",
    "   #         y = y[Yindices]\n",
    "                print(os.path.join(file_path+'_'+str(i), 'progress.csv') +' ' +str(len(y)))\n",
    "                Y = np.concatenate((Y,y),axis=0)\n",
    "    Y = Y[:n]\n",
    "    X = range(len(Y))\n",
    "    X = X[:n]\n",
    "    matplotlib.pyplot.plot(X, Y)\n",
    "\n",
    "    if mavg_v == 1:\n",
    "        Ymavg = moving_average(Y)\n",
    "        matplotlib.pyplot.plot(X, Ymavg, 'r', linewidth=4)\n",
    "    elif mavg_v == 2:\n",
    "        Ymavg = moving_average_v2(Y, n=conv)\n",
    "        matplotlib.pyplot.plot(X[conv-1:], Ymavg, 'r', linewidth=4)\n",
    "\n",
    "    matplotlib.pyplot.title(file_path.split(\"/\")[-2], fontsize=16)\n",
    "    print(len(Ymavg))\n",
    "    delta = Ymavg[-1] - Ymavg[0]\n",
    "    font = {'family': 'serif',\n",
    "            'color':  'darkred',\n",
    "            'weight': 'normal',\n",
    "            'size': 12,}\n",
    "    bbox_dict = {'facecolor':'white', 'alpha':1.0, 'pad':7}\n",
    "    matplotlib.pyplot.text(0, int(max(Y))-txt_offset,\n",
    "        'Len = {} Reward Delta = {}'.format(len(Y), delta), fontdict=font, bbox=bbox_dict)\n",
    "    return len(Y), delta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "import matplotlib\n",
    "import numpy as np\n",
    "import pickle\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns; sns.set(color_codes=True)\n",
    "import seaborn\n",
    "%matplotlib inline  \n",
    "matplotlib.rcParams['figure.figsize'] =(12, 5)\n",
    "#seaborn.set(rc={'axes.facecolor':'#F2FCFF', 'figure.facecolor':'#F2FCFF'})\n",
    "\n",
    "def smooth(row, explen=None):\n",
    "    if explen is None:\n",
    "        N = max(int(len(row)*0.02), 1)\n",
    "    else:\n",
    "        N = max(int(explen*0.02), 1)\n",
    "    row = np.convolve(row, np.array(np.ones((N)))/float(N), 'valid')\n",
    "    return row\n",
    "\n",
    "def plot(fields, first=None, legends=None, alpha=None, rescale_y=None, startpoints=None):\n",
    "    lines = []\n",
    "    for field in fields:\n",
    "        for ind, (data, header) in enumerate(zip(datas, headers)):\n",
    "            try:\n",
    "                header.index(field)\n",
    "                row = data[:, header.index(field)]\n",
    "                row = smooth(row, first)[:first]\n",
    "                _alpha = alpha if alpha else (0.2 if row.shape[0] == first else 1.0)\n",
    "                if rescale_y:\n",
    "                    row = (row-rescale_y[0])/(rescale_y[1]-rescale_y[0])*100\n",
    "                if startpoints is None:\n",
    "                    line, =plt.plot(range(row.shape[0]), row, alpha=_alpha)\n",
    "                else:\n",
    "                    line, =plt.plot(range(startpoints[ind], startpoints[ind]+row.shape[0]),\n",
    "                                    row, alpha=_alpha)\n",
    "                lines.append(line)\n",
    "            except:\n",
    "                pass\n",
    "    if first is not None:\n",
    "        plt.xlim(0, first)\n",
    "    plt.legend(handles=lines, labels=legends if legends else filenames)  # , loc=4)\n",
    "\n",
    "def readfile(filename):\n",
    "    print(filename)\n",
    "    with open(filename) as f:\n",
    "        #data = map(lambda x: x.strip().split(','), f.readlines())\n",
    "        data = list(map(lambda x: x.strip().split(','), f.readlines()))\n",
    "    if len(data) is 0 :\n",
    "        return None, None\n",
    "    header = data[0]\n",
    "    data = np.array(data[1:])\n",
    "    data[data == ''] = '0'\n",
    "    try :\n",
    "        data = np.array(data, dtype='float')\n",
    "    except :\n",
    "        for e in data :\n",
    "            try :\n",
    "                np.array(e, dtype='float')\n",
    "            except :\n",
    "                print(e)\n",
    "    return header, data\n",
    "\n",
    "def parse_target(targets):\n",
    "    filenames, startpoints = [], []\n",
    "    for target in targets:\n",
    "        if isinstance(target, tuple):\n",
    "            filenames.append(target[0])\n",
    "            startpoints.append(target[1])\n",
    "        else:\n",
    "            filenames.append(target)\n",
    "            startpoints.append(0)\n",
    "    #filenames = map(lambda x: './outputs/'+x, filenames)\n",
    "    filenames = list(map(lambda x: './outputs/'+x, filenames))\n",
    "    return filenames, startpoints\n",
    "\n",
    "def moving_average(a) :\n",
    "    ret = np.cumsum(a, dtype=float)\n",
    "    rng = np.asarray(range(1,len(a)+1), dtype=float)\n",
    "    ret = np.divide(ret, rng)\n",
    "    return ret\n",
    "\n",
    "\n",
    "def moving_average_v2(a, n=10):\n",
    "    ret = np.cumsum(a, dtype=float)\n",
    "    ret[n:] = ret[n:] - ret[:-n]\n",
    "    return ret[n - 1:] / n\n",
    "\n",
    "\n",
    "def plot_reward_curve(file_path, mavg=True, mavg_v=1, n=-1, target_field='EpRewMean',\n",
    "                      print_header=False, txt_offset=1.0, conv=100, newfig=True):\n",
    "    if newfig:\n",
    "        plt.figure()\n",
    "    \n",
    "    \n",
    "    cont =  'progress' not in file_path\n",
    "    if cont :\n",
    "        header, data = readfile(os.path.join(file_path, 'progress.csv'))\n",
    "    else :\n",
    "        header, data = readfile(file_path)\n",
    "    if print_header:\n",
    "        print (header)\n",
    "    target_field_index = header.index(target_field)\n",
    "    Y = data[:, target_field_index]\n",
    "    Yindices = np.where(Y !=0)\n",
    "    Y = Y[Yindices]\n",
    "    \n",
    "    t=2\n",
    "#    print((len(Y)%5)*5)\n",
    "#    Y = Y[:(len(Y)%5)*5]\n",
    "    print(len(Y))\n",
    "    if cont :\n",
    "        while os.path.exists(file_path+'_'+str(t)) :\n",
    "            t += 1\n",
    "        if t > 2 :\n",
    "            for i in range(t) :\n",
    "                if i <2 :\n",
    "                    continue\n",
    "            \n",
    "                head,d = readfile(os.path.join(file_path+'_'+str(i), 'progress.csv'))\n",
    "                if head is None :\n",
    "                    continue\n",
    "                target_field_index = head.index(target_field)\n",
    "                y = d[:,target_field_index] \n",
    "                #y = y[:(len(y)%2)*2]\n",
    "                #if i is not t-1 :\n",
    "                yindices = np.where(y !=0)\n",
    "                y = y[yindices]\n",
    "                print(os.path.join(file_path+'_'+str(i), 'progress.csv') +' ' +str(len(y)))\n",
    "                Y = np.concatenate((Y,y),axis=0)\n",
    "    \n",
    "    \n",
    "#    header, data = readfile(file_path)\n",
    "#    if print_header:\n",
    "#        print (header)\n",
    "#    target_field_index = header.index(target_field)\n",
    "#    Y = data[:, target_field_index]\n",
    "#    Yindices = np.where(Y != 0)\n",
    "#    Y = Y[Yindices]\n",
    "    X = range(len(Y))\n",
    "    Y = Y[:n]\n",
    "    X = X[:n]\n",
    "    matplotlib.pyplot.plot(X, Y)\n",
    "\n",
    "    if mavg_v == 1:\n",
    "        Ymavg = moving_average(Y)\n",
    "        matplotlib.pyplot.plot(X, Ymavg, 'r', linewidth=4)\n",
    "    elif mavg_v == 2:\n",
    "        Ymavg = moving_average_v2(Y, n=conv)\n",
    "        matplotlib.pyplot.plot(X[conv-1:], Ymavg, 'r', linewidth=4)\n",
    "\n",
    "    matplotlib.pyplot.title(file_path.split(\"/\")[-2], fontsize=16)\n",
    "    delta = Ymavg[-1] - Ymavg[0]\n",
    "    font = {'family': 'serif',\n",
    "            'color':  'darkred',\n",
    "            'weight': 'normal',\n",
    "            'size': 12,}\n",
    "    bbox_dict = {'facecolor':'white', 'alpha':1.0, 'pad':7}\n",
    "    matplotlib.pyplot.text(0, int(max(Y))-txt_offset,\n",
    "        'Len = {} Reward Delta = {}'.format(len(Y), delta), fontdict=font, bbox=bbox_dict)\n",
    "    return len(Y), delta\n",
    "\n",
    "def moving_average_v2(a, n=10):\n",
    "    ret = np.cumsum(a, dtype=float)\n",
    "    ret[n:] = ret[n:] - ret[:-n]\n",
    "    return ret[n - 1:] / n\n",
    "\n",
    "def plot_reward_curve_seborn(file_path, mavg=True, mavg_v=1, n=-1, target_field='EpRewMean',\n",
    "                      print_header=False, txt_offset=1.0, conv=100, newfig=True, a_min=-100):\n",
    "    if newfig:\n",
    "        plt.figure(figsize=(8, 5))\n",
    "        \n",
    "        \n",
    "    \n",
    "    cont =  'progress.csv' not in file_path\n",
    "    if cont :\n",
    "        header, data = readfile(os.path.join(file_path, 'progress.csv'))\n",
    "    else :\n",
    "        header, data = readfile(file_path)\n",
    "    if print_header:\n",
    "        print (header)\n",
    "    target_field_index = header.index(target_field)\n",
    "    Y = data[:, target_field_index]\n",
    "    print(len(Y))\n",
    "    t=2\n",
    "#    print((len(Y)%5)*5)\n",
    "#    Y = Y[:(len(Y)%5)*5]\n",
    "    print(len(Y))\n",
    "    if cont :\n",
    "        while os.path.exists(file_path+'_'+str(t)) :\n",
    "            t += 1\n",
    "        if t > 2 :\n",
    "            for i in range(t) :\n",
    "                if i <2 :\n",
    "                    continue\n",
    "            \n",
    "                head,d = readfile(os.path.join(file_path+'_'+str(i), 'progress.csv'))\n",
    "                if head is None :\n",
    "                    continue\n",
    "                target_field_index = head.index(target_field)\n",
    "                y = d[:,target_field_index] \n",
    "                #y = y[:(len(y)%2)*2]\n",
    "                if i is not t-1 :\n",
    "                    yindices = np.where(y != 0)\n",
    "   #         y = y[Yindices]\n",
    "                print(os.path.join(file_path+'_'+str(i), 'progress.csv') +' ' +str(len(y)))\n",
    "                Y = np.concatenate((Y,y),axis=0)    \n",
    "\n",
    "    X = range(len(Y))\n",
    "    Y = np.asarray(Y[:n])\n",
    "    X = np.asarray(X[:n]) * 50\n",
    "    avg_x, avg_y = np.mean(X), np.mean(Y)\n",
    "    min_x, min_y = np.min(X),  np.min(Y)\n",
    "    max_x, max_y = np.max(X),  np.max(Y)\n",
    "    std_x, std_y = np.std(X),  np.std(Y)\n",
    "    # matplotlib.pyplot.plot(X, Y)\n",
    "    # plt.fill_between(np.arange(len(Y)), Y - std_y, Y + std_y, alpha=0.2)\n",
    "    Ymavg_u = moving_average_v2(Y+std_y, n=conv)\n",
    "    Ymavg_d = moving_average_v2(Y-std_y, n=conv)\n",
    "    # matplotlib.pyplot.plot(X[conv-1:], Ymavg_u, 'r', linewidth=4)\n",
    "    # matplotlib.pyplot.plot(X[conv-1:], Ymavg_d, 'r', linewidth=4)\n",
    "    Ymavg = moving_average_v2(Y, n=conv)\n",
    "    plt.fill_between(X[conv-1:], np.clip(Ymavg_d, a_min=a_min, a_max=None), Ymavg_u, alpha=0.2)\n",
    "    matplotlib.pyplot.plot(X[conv-1:], Ymavg, linewidth=4)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_reward_curve_seborn(file_path, mavg=True, mavg_v=1, n=-1, target_field='EpRewMean',\n",
    "                      print_header=False, txt_offset=1.0, conv=100, newfig=True, a_min=-100):\n",
    "    if newfig:\n",
    "        plt.figure(figsize=(8, 5))\n",
    "    \n",
    "    cont =  'progress' not in file_path\n",
    "    if cont :\n",
    "        header, data = readfile(os.path.join(file_path, 'progress.csv'))\n",
    "    else :\n",
    "        header, data = readfile(file_path)\n",
    "    if print_header:\n",
    "        print (header)\n",
    "    target_field_index = header.index(target_field)\n",
    "    Y = data[:, target_field_index]\n",
    "    print(len(Y))\n",
    "    t=2\n",
    "#    print((len(Y)%5)*5)\n",
    "#    Y = Y[:(len(Y)%5)*5]\n",
    "    print(len(Y))\n",
    "    if cont :\n",
    "        print(\"C\")\n",
    "        while os.path.exists(os.path.join(file_path, 'progress_{}.csv'.format(t))) :\n",
    "            t += 1\n",
    "        if t > 2 :\n",
    "            for i in range(t) :\n",
    "                if i <2 :\n",
    "                    continue\n",
    "                head,d = readfile(os.path.join(file_path, 'progress_{}.csv'.format(i)))\n",
    "                if head is None :\n",
    "                    continue\n",
    "                target_field_index = head.index(target_field)\n",
    "                y = d[:,target_field_index] \n",
    "                #y = y[:(len(y)%2)*2]\n",
    "                if i is not t-1 :\n",
    "                    yindices = np.where(y != 0)\n",
    "   #         y = y[Yindices]\n",
    "                print(os.path.join(file_path, 'progress_{}.csv'.format(i)) +' ' +str(len(y)))\n",
    "                Y = np.concatenate((Y,y),axis=0)    \n",
    "        \n",
    "  #  header, data = readfile(file_path)\n",
    "  #  if print_header:\n",
    "  #      print (header)\n",
    "  #  target_field_index = header.index(target_field)\n",
    "  #  Y = data[:, target_field_index]\n",
    "  #  Yindices = np.where(Y != 0)\n",
    "  #  Y = Y[Yindices]\n",
    "    X = range(len(Y))\n",
    "    Y = np.asarray(Y[:n])\n",
    "    X = np.asarray(X[:n]) * 50\n",
    "    avg_x, avg_y = np.mean(X), np.mean(Y)\n",
    "    min_x, min_y = np.min(X),  np.min(Y)\n",
    "    max_x, max_y = np.max(X),  np.max(Y)\n",
    "    std_x, std_y = np.std(X),  np.std(Y)\n",
    "    # matplotlib.pyplot.plot(X, Y)\n",
    "    # plt.fill_between(np.arange(len(Y)), Y - std_y, Y + std_y, alpha=0.2)\n",
    "    Ymavg_u = moving_average_v2(Y+std_y, n=conv)\n",
    "    Ymavg_d = moving_average_v2(Y-std_y, n=conv)\n",
    "    # matplotlib.pyplot.plot(X[conv-1:], Ymavg_u, 'r', linewidth=4)\n",
    "    # matplotlib.pyplot.plot(X[conv-1:], Ymavg_d, 'r', linewidth=4)\n",
    "    Ymavg = moving_average_v2(Y, n=conv)\n",
    "    plt.fill_between(X[conv-1:], np.clip(Ymavg_d, a_min=a_min, a_max=None), Ymavg_u, alpha=0.2)\n",
    "    matplotlib.pyplot.plot(X[conv-1:], Ymavg, linewidth=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/data1/jaed/test_1017_oicr_seq_no_div_2/log/progress_4.csv\n",
      "44\n",
      "44\n",
      "/data1/jaed/test_1017_oicr_seq_no_div_2/log/progress_4.csv\n",
      "44\n",
      "44\n",
      "/data1/jaed/test_1017_oicr_seq_no_div_2/log/progress_4.csv\n",
      "44\n",
      "44\n",
      "/data1/jaed/test_1017_oicr_seq_no_div_2/log/progress_4.csv\n",
      "44\n",
      "44\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f9208dd2fd0>"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "N= 10000\n",
    "file_path = 'results/test_single/log/'\n",
    "plot_reward_curve_seborn(file_path, mavg=True, mavg_v=1, n=N,\n",
    "                                     target_field='midn_loss', print_header=False,\n",
    "                                     txt_offset=1.0, newfig=True, conv=20)\n",
    "plt.legend(['wsddn_loss'],fontsize=14)\n",
    "plot_reward_curve_seborn(file_path, mavg=True, mavg_v=1, n=N,\n",
    "                                     target_field='oicr_loss1', print_header=False,\n",
    "                                     txt_offset=1.0, newfig=True, conv=20)\n",
    "\n",
    "plot_reward_curve_seborn(file_path, mavg=True, mavg_v=1, n=N,\n",
    "                                     target_field='oicr_loss2', print_header=False,\n",
    "                                     txt_offset=1.0, newfig=False, conv=20)\n",
    "plot_reward_curve_seborn(file_path, mavg=True, mavg_v=1, n=N,\n",
    "                                     target_field='oicr_loss3', print_header=False,\n",
    "                                     txt_offset=1.0, newfig=False, conv=20)\n",
    "plt.legend(['oicr_loss_1','oicr_loss_2','oicr_loss_3'],fontsize=14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
